1. Field of the Invention
The present invention relates generally to user interfaces and, more particularly, to specification of interface elements.
2. Background and Material Information
To work with a system, users require the ability to control the system and assess its state (e.g., input data and view data output). Typically such control has been accomplished through the use of user interfaces (UI). Numerous variations on UIs exist within the information technology realm. For example, a computer based UI may accept input via devices such as a computer keyboard and a mouse, while providing articulated graphical output on the computer monitor. Web-based user interfaces may also accept input and provide output by generating web pages which are transported via the Internet and viewed by the user using a web browser program. Other UIs may include, for example, command line interfaces, touch interfaces, tangible interfaces, and telephone interfaces.
Object-oriented techniques have become a preferred method for UI development primarily because of its wide availability and the reusability of code and objects. An “object” generally means a software bundle of variables (e.g., data) and related methods (e.g., events) that can be used to define the behavior, appearance, and layout of a UI element (e.g., text box, pushbutton, menu, etc.). For example, in object-oriented programming, an instance of an object is a concrete realization of a class that consists of data and the operations associated with that data. Such a class may be, for example, a pushbutton or a textbox for accepting user input. The class may have particular base attributes and behaviors that come predefined within the class and may define how an instance of the class may appear (e.g., borders and colors) and behave (e.g., button press) within a UI. In other words, the presentation layer and definition are intertwined within the object.
Similar tasks may be accomplished in each interface type using a UI that, while utilizing UI elements that are semantically similar, are perceived differently. For example, a pushbutton in an interface developed in Java and executed as a stand-alone application on a Unix platform may have a very different appearance from a pushbutton in a Microsoft Windows application. Further, object events, properties, and string-derived identifiers may differ substantially, both in availability and function, from one variation to the next, based on the software development platform (e.g., Microsoft .NET Framework, Java, and the like), the rendering engine utilized (e.g., Smart Client Windows Renderer, SAP Unified Rendering, etc.), and the platform (e.g., Unix, Windows, Apple, and so forth). Such variation makes it difficult for developers to communicate using standard language and develop versatile, reusable software code for the multitude of devices, rendering engines, and platforms that are constantly being developed (e.g., mobile phones, personal digital assistants, etc.).
Over time, developers have utilized different methods for standardizing semantics while allowing the presentation layer of user interface objects to change. For example, it has become desirable to present a user interface with a visually pleasing “theme” or “skin,” and to allow an end user to select what theme or skin is subjectively most pleasing. A theme or skin is generally a preset package containing graphical appearance details (e.g., colors, translucency, fonts, layout, etc.) used to customize the look and feel of an operating system, widget set, application, and window manager, among other things. Therefore, developers of user interfaces have tried to implement techniques enabling some semantic correlation while allowing appearances of objects in the presentation layer to be changed.
These themes may be described insufficiently with meta-data. For example, a cascading style sheet (CSS) may be applied to a defined interface at runtime for application of a theme or skin, particularly within a Web Interface. CSS is designed primarily to enable the separation of interface/document content (written in HTML or a similar language) from document presentation (written in CSS). While this separation can provide more flexibility and control in the specification of presentational characteristics, and also allow the same markup page to be presented in different styles for different rendering methods, CSS presents some problems. CSS are generally developed in tandem with the user interface to which it applies. In other words, at runtime, the user interface must know where to locate the CSS and will be expecting particular presentation layer definitions to be present within the CSS. Further, the semantics used within the CSS and the user interface must be identical or the application will generally fail to apply the CSS. The definition of the UI is, therefore, intertwined with its presentation layer.
CSS further lacks the ability to specify behaviors for particular interface objects within a user interface, however, some rendering engines have been developed to allow for behaviors along with presentation layers to be defined using meta-data. These applications also present problems in that object behavior is typically hard-coded within the interface and still requires accurate semantics for presentation layer changes at runtime.
In the view of the foregoing, there is a need for systems and methods that allow developers to separate the definition of a UI from the presentation of a UI such that presentation of UI objects depends on context of usage alone. Further, there is a need for systems and methods to free developers of semantics while defining UIs to be used across a wide array of platforms, rendering engines, and themes (i.e., context) without compromising flexibility of design.
The disclosed systems and methods are directed to overcoming one or more of the problems set forth above.